1class User:
2    def __init__(self, name: str):
3        self.id = str(uuid.uuid4())
4        self.name = name
5
6    def get_id(self) -> str:
7        return self.id
8
9    def get_name(self) -> str:
10        return self.name
11
12    def on_message_received(self, message: 'Message', chat_context: 'Chat'):
13        print(f"[Notification for {self.get_name()} in chat '{chat_context.get_name(self)}'] {message.get_sender().get_name()}: {message.get_content()}")
14
15    def __eq__(self, other):
16        if self is other:
17            return True
18        if other is None or type(self) != type(other):
19            return False
20        return self.id == other.id
21
22    def __hash__(self):
23        return hash(self.id)
24
25    def __str__(self):
26        return f"User{{id='{self.id}', name='{self.name}'}}"

1class Message:
2    def __init__(self, sender: User, content: str):
3        self.id = str(uuid.uuid4())
4        self.sender = sender
5        self.content = content
6        self.timestamp = datetime.now()
7
8    def get_id(self) -> str:
9        return self.id
10
11    def get_sender(self) -> User:
12        return self.sender
13
14    def get_content(self) -> str:
15        return self.content
16
17    def get_timestamp(self) -> datetime:
18        return self.timestamp
19
20    def __str__(self):
21        return f"[{self.timestamp}] {self.sender.get_name()}: {self.content}"

1class Chat(ABC):
2    def __init__(self):
3        self.id = str(uuid.uuid4())
4        self.members: List[User] = []
5        self.messages: List[Message] = []
6        self._lock = Lock()
7
8    def get_id(self) -> str:
9        return self.id
10
11    def get_members(self) -> List[User]:
12        with self._lock:
13            return copy.copy(self.members)
14
15    def get_messages(self) -> List[Message]:
16        with self._lock:
17            return copy.copy(self.messages)
18
19    def add_message(self, message: Message):
20        with self._lock:
21            self.messages.append(message)
22
23    @abstractmethod
24    def get_name(self, perspective_user: User) -> str:
25        pass

1class OneToOneChat(Chat):
2    def __init__(self, user1: User, user2: User):
3        super().__init__()
4        self.members.extend([user1, user2])
5
6    def get_name(self, perspective_user: User) -> str:
7        for member in self.members:
8            if member != perspective_user:
9                return member.get_name()
10        return "Unknown Chat"

1class GroupChat(Chat):
2    def __init__(self, group_name: str, initial_members: List[User]):
3        super().__init__()
4        self.group_name = group_name
5        self.members.extend(initial_members)
6
7    def add_member(self, user: User):
8        with self._lock:
9            if user not in self.members:
10                self.members.append(user)
11
12    def remove_member(self, user: User):
13        with self._lock:
14            if user in self.members:
15                self.members.remove(user)
16
17    def get_name(self, perspective_user: User) -> str:
18        return self.group_name

1class ChatService:
2    def __init__(self):
3        self.users: Dict[str, User] = {}
4        self.chats: Dict[str, Chat] = {}
5        self._lock = Lock()
6
7    def create_user(self, name: str) -> User:
8        user = User(name)
9        with self._lock:
10            self.users[user.get_id()] = user
11        return user
12
13    def create_one_to_one_chat(self, user_id1: str, user_id2: str) -> Chat:
14        user1 = self.users.get(user_id1)
15        user2 = self.users.get(user_id2)
16        chat = OneToOneChat(user1, user2)
17        with self._lock:
18            self.chats[chat.get_id()] = chat
19        return chat
20
21    def create_group_chat(self, name: str, member_ids: List[str]) -> Chat:
22        members = []
23        for member_id in member_ids:
24            members.append(self.users.get(member_id))
25        chat = GroupChat(name, members)
26        with self._lock:
27            self.chats[chat.get_id()] = chat
28        return chat
29
30    def send_message(self, sender_id: str, chat_id: str, message_content: str):
31        sender = self.users.get(sender_id)
32        chat = self.chats.get(chat_id)
33        
34        if chat is None:
35            print(f"Error: Chat not found with ID: {chat_id}")
36            return
37
38        if sender not in chat.get_members():
39            print(f"Error: Sender {sender.get_name()} is not a member of this chat.")
40            return
41
42        message = Message(sender, message_content)
43        chat.add_message(message)
44
45        # Notify all members of the chat (Observer pattern)
46        for member in chat.get_members():
47            # Do not send a notification to the sender
48            if member != sender:
49                member.on_message_received(message, chat)
50
51    def print_chat_history(self, chat_id: str) -> List[Message]:
52        chat = self.chats.get(chat_id)
53        if chat is not None:
54            return chat.get_messages()
55        return []
56
57    def get_user_chats(self, user_id: str) -> List[Chat]:
58        user = self.users.get(user_id)
59        if user is None:
60            return []
61        
62        result = []
63        for chat in self.chats.values():
64            if user in chat.get_members():
65                result.append(chat)
66        return result

1class ChatApplicationDemo:
2    @staticmethod
3    def main():
4        # 1. Initialize the Mediator (ChatService)
5        chat_service = ChatService()
6
7        # 2. Create and register users
8        alice = chat_service.create_user("Alice")
9        bob = chat_service.create_user("Bob")
10        charlie = chat_service.create_user("Charlie")
11
12        print("--- Users registered in the system ---")
13        print()
14
15        # 3. Scenario 1: One-on-one chat between Alice and Bob
16        print("--- Starting one-on-one chat between Alice and Bob ---")
17        alice_bob_chat = chat_service.create_one_to_one_chat(alice.get_id(), bob.get_id())
18
19        # Alice sends a message to Bob
20        print("Alice sends a message...")
21        chat_service.send_message(alice.get_id(), alice_bob_chat.get_id(), "Hi Bob, how are you?")
22
23        # Bob sends a reply
24        print("\nBob sends a reply...")
25        chat_service.send_message(bob.get_id(), alice_bob_chat.get_id(), "I'm good, Alice! Thanks for asking.")
26        print()
27
28        # 4. Scenario 2: Group chat
29        print("--- Starting a group chat for a 'Project Team' ---")
30        project_members = [alice.get_id(), bob.get_id(), charlie.get_id()]
31        project_group = chat_service.create_group_chat("Project Team", project_members)
32
33        # Charlie sends a message to the group
34        print("Charlie sends a message to the group...")
35        chat_service.send_message(charlie.get_id(), project_group.get_id(), "Hey team, when is our deadline?")
36
37        # Alice replies to the group
38        print("\nAlice replies to the group...")
39        chat_service.send_message(alice.get_id(), project_group.get_id(), "It's next Friday. Let's sync up tomorrow.")
40        print()
41
42        # 5. Demonstrate fetching chat history
43        print("--- Fetching Chat Histories ---")
44
45        # History of Alice and Bob's chat
46        print(f"\nHistory for chat '{alice_bob_chat.get_name(alice)}':")
47        one_to_one_history = chat_service.print_chat_history(alice_bob_chat.get_id())
48        for message in one_to_one_history:
49            print(message)
50
51        # History of the project group chat
52        print(f"\nHistory for chat '{project_group.get_name(charlie)}':")
53        group_history = chat_service.print_chat_history(project_group.get_id())
54        for message in group_history:
55            print(message)
56
57        # 6. Demonstrate finding all of a user's chats
58        print("\n--- Fetching all of Alice's chats ---")
59        alice_chats = chat_service.get_user_chats(alice.get_id())
60        for chat in alice_chats:
61            print(f"Chat: {chat.get_name(alice)} (ID: {chat.get_id()})")
62
63
64if __name__ == "__main__":
65    ChatApplicationDemo.main()